package com.lizicloud.user.userupdate.service;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.lizicloud.infrastructure.common.exception.BusinessException;
import com.lizicloud.user.userupdate.dto.UserUpdateDTO;
import com.lizicloud.user.userupdate.dto.UserUpdateResponseDTO;
import com.lizicloud.user.userupdate.converter.UserUpdateConverter;
import com.lizicloud.domain.model.User;
import com.lizicloud.user.userupdate.mapper.UserUpdateMapper;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.time.LocalDateTime;

/**
 * 用户更新服务 - 专门处理前端用户更新功能
 * 提供完整的用户更新逻辑，包括数据验证、转换和响应处理
 */
@Slf4j
@Service
public class UserUpdateService {
    
    @Autowired
    private UserUpdateMapper userUpdateMapper;
    
    @Autowired
    private UserUpdateConverter userUpdateConverter;
    
    /**
     * 根据ID获取用户信息
     * 
     * @param id 用户ID
     * @return 用户更新响应DTO
     */
    public UserUpdateResponseDTO getUserById(Long id) {
        log.info("获取用户信息，用户ID: {}", id);
        
        if (id == null || id <= 0) {
            throw new BusinessException("PARAMS_ERROR", "用户ID不能为空或小于等于0");
        }
        
        LambdaQueryWrapper<User> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(User::getId, id)
                   .eq(User::getIsDelete, 0); // 只查询未删除的用户
        
        User user = userUpdateMapper.selectOne(queryWrapper);
        if (user == null) {
            throw new BusinessException("NOT_FOUND_ERROR", "用户不存在");
        }
        
        return userUpdateConverter.toResponseDTO(user);
    }
    
    /**
     * 更新用户信息 - 完整更新
     * 支持用户名、邮箱、手机号、角色、状态、头像、备注等字段的更新
     * 
     * @param updateDTO 用户更新信息
     * @return 更新后的用户信息
     */
    @Transactional(rollbackFor = Exception.class)
    public UserUpdateResponseDTO updateUser(UserUpdateDTO updateDTO) {
        log.info("更新用户信息，用户ID: {}, 更新内容: {}", updateDTO.getId(), updateDTO);
        
        // 验证用户是否存在
        User existingUser = userUpdateMapper.selectById(updateDTO.getId());
        if (existingUser == null) {
            throw new BusinessException("NOT_FOUND_ERROR", "用户不存在");
        }
        
        // 检查用户名是否已存在（排除当前用户）
        LambdaQueryWrapper<User> usernameCheckWrapper = new LambdaQueryWrapper<>();
        usernameCheckWrapper.eq(User::getUsername, updateDTO.getUsername())
                           .ne(User::getId, updateDTO.getId())
                           .eq(User::getIsDelete, 0); // 只检查未删除的用户
        if (userUpdateMapper.selectCount(usernameCheckWrapper) > 0) {
            throw new BusinessException("PARAMS_ERROR", "用户名已存在");
        }
        
        // 检查邮箱是否已存在（排除当前用户）
        String email = updateDTO.getEmail();
        // 处理空字符串邮箱问题 - 空字符串转换为null避免UNIQUE约束冲突
        String processedEmail = (email != null && email.trim().isEmpty()) ? null : email;
        if (processedEmail != null && !processedEmail.isEmpty()) {
            LambdaQueryWrapper<User> emailCheckWrapper = new LambdaQueryWrapper<>();
            emailCheckWrapper.eq(User::getEmail, processedEmail)
                             .ne(User::getId, updateDTO.getId())
                             .eq(User::getIsDelete, 0); // 只检查未删除的用户
            if (userUpdateMapper.selectCount(emailCheckWrapper) > 0) {
                throw new BusinessException("PARAMS_ERROR", "邮箱地址已存在");
            }
        }
        
        // 构建更新条件
        LambdaUpdateWrapper<User> updateWrapper = new LambdaUpdateWrapper<>();
        updateWrapper.eq(User::getId, updateDTO.getId());
        
        // 创建更新实体
        User userToUpdate = new User();
        userToUpdate.setUsername(updateDTO.getUsername());
        // 处理空字符串邮箱问题 - 空字符串转换为null避免UNIQUE约束冲突
        userToUpdate.setEmail(processedEmail);
        userToUpdate.setPhone(updateDTO.getPhone());
        userToUpdate.setRole(updateDTO.getRole());
        userToUpdate.setStatus(updateDTO.getStatus());
        userToUpdate.setAvatar(updateDTO.getAvatar());
        userToUpdate.setRemark(updateDTO.getRemark());
        userToUpdate.setUpdatedTime(LocalDateTime.now());
        
        // 执行更新
        int updateCount = userUpdateMapper.update(userToUpdate, updateWrapper);
        if (updateCount == 0) {
            throw new BusinessException("SYSTEM_ERROR", "更新用户信息失败");
        }
        
        log.info("用户更新成功，用户ID: {}", updateDTO.getId());
        
        // 返回更新后的用户信息
        return getUserById(updateDTO.getId());
    }
    
    /**
     * 批量更新用户状态
     * 
     * @param userIds 用户ID列表
     * @param status 状态值
     * @return 更新成功的数量
     */
    @Transactional(rollbackFor = Exception.class)
    public int batchUpdateUserStatus(java.util.List<Long> userIds, Integer status) {
        log.info("批量更新用户状态，用户ID列表: {}, 状态: {}", userIds, status);
        
        if (userIds == null || userIds.isEmpty()) {
            throw new BusinessException("PARAMS_ERROR", "用户ID列表不能为空");
        }
        
        if (status == null || (status != 0 && status != 1)) {
            throw new BusinessException("PARAMS_ERROR", "状态值只能是0或1");
        }
        
        LambdaUpdateWrapper<User> updateWrapper = new LambdaUpdateWrapper<>();
        updateWrapper.in(User::getId, userIds)
                     .eq(User::getIsDelete, 0) // 只更新未删除的用户
                     .set(User::getStatus, status)
                     .set(User::getUpdatedTime, LocalDateTime.now());
        
        return userUpdateMapper.update(null, updateWrapper);
    }
}